First cut at support for setting the domains for block and net backends.
import XendConsole
import EventServer
+from xenmgr.server import SrvConsoleServer
+xend = SrvConsoleServer.instance()
+
eserver = EventServer.instance()
__all__ = [ "XendDomain" ]
def initial_refresh(self):
"""Refresh initial domain info from domain_db.
"""
- print "initial_refresh> db=", self.domain_db.values()
+ print "initial_refresh>"
+ for d in self.domain_db.values(): print 'db dom=', d
domlist = xc.domain_getinfo()
- print "doms=", domlist
+ for d in domlist: print 'xc dom=', d
doms = {}
for d in domlist:
domid = str(d['dom'])
doms[domid] = d
for config in self.domain_db.values():
- domid = int(sxp.child_value(config, 'id'))
+ domid = str(sxp.child_value(config, 'id'))
print "dom=", domid, "config=", config
if domid in doms:
print "dom=", domid, "new"
config = None
image = None
newinfo = XendDomainInfo.XendDomainInfo(
- config, d['dom'], d['name'], d['mem_kb']/1024, image)
+ config, d['dom'], d['name'], d['mem_kb']/1024, image=image, info=d)
self._add_domain(newinfo.id, newinfo)
# Remove entries for domains that no longer exist.
for d in self.domain.values():
"""
dom = int(id)
eserver.inject('xend.domain.start', id)
- return xc.domain_start(dom=dom)
+ return xend.domain_start(dom)
def domain_stop(self, id):
"""Stop domain running.
"""
dom = int(id)
- return xc.domain_stop(dom=dom)
+ return xend.domain_stop(dom)
def domain_shutdown(self, id):
"""Shutdown domain (nicely).
if dom <= 0:
return 0
eserver.inject('xend.domain.shutdown', id)
- val = xc.domain_destroy(dom=dom, force=0)
+ val = xend.domain_destroy(dom, force=0)
self.refresh()
return val
if dom <= 0:
return 0
eserver.inject('xend.domain.halt', id)
- val = xc.domain_destroy(dom=dom, force=1)
+ val = xend.domain_destroy(dom, force=1)
self.refresh()
return val
class XendDomainInfo:
"""Virtual machine object."""
- def __init__(self, config, dom, name, memory, image=None, console=None):
+ def __init__(self, config, dom, name, memory, image=None, console=None, info=None):
"""Construct a virtual machine object.
config configuration
self.console = console
self.devices = {}
self.configs = []
- self.info = None
+ self.info = info
self.ipaddrs = []
+ self.block_controller = 0
+ self.net_controller = 0
#todo: state: running, suspended
self.state = 'running'
['name', self.name],
['memory', self.memory] ]
if self.info:
+ print 'info:', self.info
run = (self.info['running'] and 'r') or '-'
block = (self.info['blocked'] and 'b') or '-'
stop = (self.info['stopped'] and 's') or '-'
print '<vm_create_devices'
return deferred
+def config_controllers(vm, config):
+ for c in sxp.children(config, 'controller'):
+ name = sxp.name(c)
+ if name == 'block':
+ vm.block_controller = 1
+ xend.blkif_set_control_domain(vm.dom)
+ elif name == 'net':
+ vm.net_controller = 1
+ xend.netif_set_control_domain(vm.dom)
+ else:
+ raise VmError('invalid controller type:' + str(name))
+
def vm_configure(vm, config):
"""Configure a vm.
returns Deferred - calls callback with vm
"""
- d = xend.blkif_create(vm.dom)
+ config_controllers(vm, config)
+ if vm.block_controller:
+ d = xend.blkif_create(vm.dom)
+ else:
+ d = defer.Deferred()
+ d.callback(1)
d.addCallback(_vm_configure1, vm, config)
return d
val vif config
index vif index
"""
+ if vm.net_controller:
+ raise VmError('vif: vif in control domain')
vif = index #todo
vmac = sxp.child_value(val, "mac")
+ bridge = sxp.child_value(val, "bridge") # todo
defer = make_vif(vm.dom, vif, vmac)
def fn(id):
dev = val + ['vif', vif]
val vbd config
index vbd index
"""
+ if vm.block_controller:
+ raise VmError('vbd: vbd in control domain')
uname = sxp.child_value(val, 'uname')
if not uname:
raise VMError('vbd: Missing uname')
defer.addCallback(fn)
return defer
+def parse_pci(val):
+ if isinstance(val, StringType):
+ radix = 10
+ if val.startswith('0x') or val.startswith('0X'):
+ radix = 16
+ v = int(val, radix)
+ else:
+ v = val
+ return v
+
def vm_dev_pci(vm, val, index):
bus = sxp.child_value(val, 'bus')
if not bus:
if not func:
raise VMError('pci: Missing func')
try:
- bus = int(bus, 16)
- dev = int(dev, 16)
- func = int(func, 16)
+ bus = parse_pci(bus)
+ dev = parse_pci(dev)
+ func = parse_pci(func)
except:
raise VMError('pci: invalid parameter')
rc = xc.physdev_pci_access_modify(dom=vm.dom, bus=bus, dev=dev, func=func, enable=1)
return d
def setControlDomain(self, dom):
- if self.channel:
- self.deregisterChannel()
- self.attached = 0
+ if self.dom == dom: return
+ self.deregisterChannel()
+ self.attached = 0
self.dom = dom
self.registerChannel()
#
# xend.blkif.recovery = True
#xend.blkif.be_port = xend.main.port_from_dom(dom)
+ def getControlDomain(self):
+ return self.dom
+
def recv_be_create(self, msg, req):
#print 'recv_be_create>'
val = unpackMsg('blkif_be_create_t', msg)
blkif = self.getInstanceByDom(dom)
if blkif:
blkif.reattach_device(vdev)
+ self.attached = self.devices_attached()
+ if self.attached:
+ self.reattached()
+
+ def devices_attached(self):
+ """Check if all devices are attached.
+ """
attached = 1
for blkif in self.getInstances():
if not blkif.attached:
attached = 0
break
- self.attached = attached
- if self.attached:
- self.reattached()
-
+ return attached
+
def reattached(self):
for blkif in self.getInstances():
blkif.reattached()
return self.factory.addDeferred()
def detach(self):
+ """Detach all devices, when the back-end control domain has changed.
+ """
self.attached = 0
for dev in self.devices.values():
dev.attached = 0
self.send_be_vbd_create(vdev)
def reattach_device(self, vdev):
+ """Reattach a device, when the back-end control domain has changed.
+ """
dev = self.devices[vdev]
dev.attached = 1
attached = 1
return self.attached
def reattached(self):
+ """All devices have been reattached after the back-end control domain has changed.
+ """
msg = packMsg('blkif_fe_interface_status_changed_t',
{ 'handle' : 0,
'status' : BLKIF_INTERFACE_STATUS_DISCONNECTED})
def setControlDomain(self, dom):
"""Set the 'back-end' device driver domain.
"""
+ if self.dom == dom: return
self.deregisterChannel()
self.attached = 0
self.dom = dom
# xend.netif.recovery = True
# xend.netif.be_port = xend.main.port_from_dom(dom)
#
- pass
+
+ def getControlDomain(self):
+ return self.dom
def recv_be_create(self, msg, req):
self.callDeferred(0)
val = unpackMsg('netif_be_driver_status_changed_t', msg)
status = val['status']
if status == NETIF_DRIVER_STATUS_UP and not self.attached:
+ # If we are not attached the driver domain was changed, and
+ # this signals the new driver domain is ready.
for netif in self.getInstances():
netif.reattach_devices()
self.attached = 1
return d
def reattach_devices(self):
+ """Reattach all devices when the back-end control domain has changed.
+ """
d = self.factory.addDeferred()
self.send_be_create(vif)
self.attach_fe_devices(0)
'rx_shmem_frame' : val['rx_shmem_frame'] })
self.factory.writeRequest(msg)
- #def recv_fe_interface_status_changed(self):
- # print 'recv_fe_interface_status_changed>'
- # pass
-
def send_interface_connected(self, vif):
dev = self.devices[vif]
msg = packMsg('netif_fe_interface_status_changed_t',
projects / xen.git / commitdiff